{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.模型选择和交叉验证\n",
    "## 4.1。交叉验证评估器\n",
    "### 4.1.2 交叉验证生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-07T05:36:34.733388900Z",
     "start_time": "2023-09-07T05:36:33.852036900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用KFold(),寻找最优参数\n",
      "******************************\n",
      "alpha=0.001,R2= 0.46668269719154093\n",
      "------------------------------\n",
      "alpha=0.01,R2= 0.46736686141044664\n",
      "------------------------------\n",
      "alpha=0.1,R2= 0.466816722598349\n",
      "------------------------------\n",
      "alpha=1,R2= 0.3697563228248995\n",
      "------------------------------\n",
      "alpha=10,R2= 0.10722961592261628\n",
      "------------------------------\n",
      "alpha=100,R2= 0.006167043894630012\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "import numpy as np\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.linear_model import Ridge\n",
    "import sklearn.metrics as metrics\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "print(\"使用KFold(),寻找最优参数\")\n",
    "print(\"*\"*30)\n",
    "# 导入糖尿病数据\n",
    "diabetes_Bunch = datasets.load_diabetes()\n",
    "X = diabetes_Bunch.data\n",
    "y = diabetes_Bunch.target\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.33,random_state=42)\n",
    "\n",
    "kfold = KFold(n_splits=7,shuffle=True,random_state=0)\n",
    "# 岭参数集合\n",
    "alphaSet = [0.001,0.01,0.1,1,10,100]\n",
    "result_scores = []\n",
    "for alpha in alphaSet:\n",
    "    R2_scores = []\n",
    "    for train,validate in kfold.split(X_train,y_train):\n",
    "        ridgeRegr = Ridge(alpha=alpha) # 创建岭回归模型\n",
    "        ridgeRegr.fit(X_train[train],y_train[train]) # 拟合模型\n",
    "\n",
    "        y_pred_val = ridgeRegr.predict(X_train[validate])\n",
    "        y_test_val = y_train[validate]\n",
    "        # 计算拟合优度指标\n",
    "        R2 = metrics.r2_score(y_test_val,y_pred_val)\n",
    "        R2_scores.append(R2)\n",
    "    result_scores.append(np.mean(R2_scores))\n",
    "    print(f'alpha={round(alpha,3)},R2=',np.mean(R2_scores))\n",
    "    print(\"-\"*30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-07T05:44:46.477443300Z",
     "start_time": "2023-09-07T05:44:46.407590200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最好的评分: 0.46736686141044664\n",
      "最佳的alpha: 0.01\n",
      "\n",
      "使用最佳超参数alpha和全部训练数据构建模型:\n",
      "Ridge(alpha=0.01)\n",
      "最后的模型指标: 0.5084083488977784\n"
     ]
    }
   ],
   "source": [
    "# 这里以拟合优度指标均值最大时对应的alpha值作为最优参数\n",
    "r2_Max = max(result_scores)\n",
    "iIndex = result_scores.index(r2_Max)\n",
    "bestAlpha = alphaSet[iIndex]\n",
    "print(\"最好的评分:\",r2_Max)\n",
    "print(\"最佳的alpha:\",bestAlpha)\n",
    "\n",
    "# 此时,可以设置alpha=bestAlpha,训练最后的模型\n",
    "print(\"\\n使用最佳超参数alpha和全部训练数据构建模型:\")\n",
    "bestRidge = Ridge(alpha=bestAlpha)\n",
    "bestRidge.fit(X_train,y_train) # 以全部训练数据拟合模型\n",
    "print(bestRidge)\n",
    "\n",
    "y_pred = bestRidge.predict(X_test)\n",
    "# 计算最后的拟合优度指标\n",
    "R2 = metrics.r2_score(y_test,y_pred)\n",
    "print(\"最后的模型指标:\",R2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.3.使用交叉验证"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-07T06:17:47.209218Z",
     "start_time": "2023-09-07T06:17:46.588096500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "参数scoring为默认值，且交叉设置为3组\n",
      "fit_time [0.00068259 0.         0.0102005 ]\n",
      "score_time [0. 0. 0.]\n",
      "test_score [0.33150734 0.08022311 0.03531764]\n",
      "------------------------------\n",
      "参数scoring设置计算多个指标,且交叉验证设置为4组\n",
      "fit_time [0.00097823 0.00096202 0.02003789 0.00086927]\n",
      "---------------------------------\n",
      "score_time [0.27133656 0.00100017 0.00096297 0.        ]\n",
      "---------------------------------\n",
      "test_r2 [ 0.3392459   0.12286347  0.16482017 -0.04610521]\n",
      "---------------------------------\n",
      "train_r2 [0.29177858 0.35449689 0.38995421 0.20300574]\n",
      "---------------------------------\n",
      "test_neg_mean_squared_error [-3638.05718248 -3595.11354697 -3878.13098976 -6455.97295283]\n",
      "---------------------------------\n",
      "train_neg_mean_squared_error [-4047.7288045  -3850.01747559 -3592.51190783 -3855.59792991]\n",
      "---------------------------------\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets,linear_model\n",
    "from sklearn.model_selection import cross_validate\n",
    "\n",
    "# 导入系统自带的糖尿病数据集,建立Lasso线性回归模型\n",
    "diabetes = datasets.load_diabetes()\n",
    "X = diabetes.data[:150]\n",
    "y = diabetes.target[:150]\n",
    "lasso = linear_model.Lasso()\n",
    "\n",
    "# 应用交叉验证,获取不同指标数据\n",
    "# 1.scoring使用默认值None,表示使用lasso模型默认Score函数\n",
    "print(\"参数scoring为默认值，且交叉设置为3组\")\n",
    "cv_result1 = cross_validate(lasso,X,y,cv=3)\n",
    "# 输出并返回结果\n",
    "for key,value in cv_result1.items():\n",
    "    print(key,value)\n",
    "print(\"-\"*30)\n",
    "# 2.这里设置参数scoring为多个指标的情况\n",
    "print(\"参数scoring设置计算多个指标,且交叉验证设置为4组\")\n",
    "cv_result2 = cross_validate(lasso,X,y,cv=4,\n",
    "                             scoring=('r2','neg_mean_squared_error'),\n",
    "                             return_train_score = True\n",
    "                             )\n",
    "# 输出并返回结果\n",
    "for key,value in cv_result2.items():\n",
    "    print(key,value)\n",
    "    print('-'*33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T01:11:45.529760200Z",
     "start_time": "2023-09-08T01:11:45.503769900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "explained_variance ----- make_scorer(explained_variance_score)\n",
      "r2 ----- make_scorer(r2_score)\n",
      "max_error ----- make_scorer(max_error, greater_is_better=False)\n",
      "neg_median_absolute_error ----- make_scorer(median_absolute_error, greater_is_better=False)\n",
      "neg_mean_absolute_error ----- make_scorer(mean_absolute_error, greater_is_better=False)\n",
      "neg_mean_squared_error ----- make_scorer(mean_squared_error, greater_is_better=False)\n",
      "neg_mean_squared_log_error ----- make_scorer(mean_squared_log_error, greater_is_better=False)\n",
      "neg_root_mean_squared_error ----- make_scorer(mean_squared_error, greater_is_better=False, squared=False)\n",
      "neg_mean_poisson_deviance ----- make_scorer(mean_poisson_deviance, greater_is_better=False)\n",
      "neg_mean_gamma_deviance ----- make_scorer(mean_gamma_deviance, greater_is_better=False)\n",
      "accuracy ----- make_scorer(accuracy_score)\n",
      "roc_auc ----- make_scorer(roc_auc_score, needs_threshold=True)\n",
      "roc_auc_ovr ----- make_scorer(roc_auc_score, needs_proba=True, multi_class=ovr)\n",
      "roc_auc_ovo ----- make_scorer(roc_auc_score, needs_proba=True, multi_class=ovo)\n",
      "roc_auc_ovr_weighted ----- make_scorer(roc_auc_score, needs_proba=True, multi_class=ovr, average=weighted)\n",
      "roc_auc_ovo_weighted ----- make_scorer(roc_auc_score, needs_proba=True, multi_class=ovo, average=weighted)\n",
      "balanced_accuracy ----- make_scorer(balanced_accuracy_score)\n",
      "average_precision ----- make_scorer(average_precision_score, needs_threshold=True)\n",
      "neg_log_loss ----- make_scorer(log_loss, greater_is_better=False, needs_proba=True)\n",
      "neg_brier_score ----- make_scorer(brier_score_loss, greater_is_better=False, needs_proba=True)\n",
      "adjusted_rand_score ----- make_scorer(adjusted_rand_score)\n",
      "homogeneity_score ----- make_scorer(homogeneity_score)\n",
      "completeness_score ----- make_scorer(completeness_score)\n",
      "v_measure_score ----- make_scorer(v_measure_score)\n",
      "mutual_info_score ----- make_scorer(mutual_info_score)\n",
      "adjusted_mutual_info_score ----- make_scorer(adjusted_mutual_info_score)\n",
      "normalized_mutual_info_score ----- make_scorer(normalized_mutual_info_score)\n",
      "fowlkes_mallows_score ----- make_scorer(fowlkes_mallows_score)\n",
      "precision ----- make_scorer(precision_score, average=binary)\n",
      "precision_macro ----- make_scorer(precision_score, pos_label=None, average=macro)\n",
      "precision_micro ----- make_scorer(precision_score, pos_label=None, average=micro)\n",
      "precision_samples ----- make_scorer(precision_score, pos_label=None, average=samples)\n",
      "precision_weighted ----- make_scorer(precision_score, pos_label=None, average=weighted)\n",
      "recall ----- make_scorer(recall_score, average=binary)\n",
      "recall_macro ----- make_scorer(recall_score, pos_label=None, average=macro)\n",
      "recall_micro ----- make_scorer(recall_score, pos_label=None, average=micro)\n",
      "recall_samples ----- make_scorer(recall_score, pos_label=None, average=samples)\n",
      "recall_weighted ----- make_scorer(recall_score, pos_label=None, average=weighted)\n",
      "f1 ----- make_scorer(f1_score, average=binary)\n",
      "f1_macro ----- make_scorer(f1_score, pos_label=None, average=macro)\n",
      "f1_micro ----- make_scorer(f1_score, pos_label=None, average=micro)\n",
      "f1_samples ----- make_scorer(f1_score, pos_label=None, average=samples)\n",
      "f1_weighted ----- make_scorer(f1_score, pos_label=None, average=weighted)\n",
      "jaccard ----- make_scorer(jaccard_score, average=binary)\n",
      "jaccard_macro ----- make_scorer(jaccard_score, pos_label=None, average=macro)\n",
      "jaccard_micro ----- make_scorer(jaccard_score, pos_label=None, average=micro)\n",
      "jaccard_samples ----- make_scorer(jaccard_score, pos_label=None, average=samples)\n",
      "jaccard_weighted ----- make_scorer(jaccard_score, pos_label=None, average=weighted)\n",
      "--------------------------------- \n",
      "\n"
     ]
    }
   ],
   "source": [
    "## 4.2.度量指标和评估(评分)\n",
    "import sklearn.metrics as metrics\n",
    "\n",
    "mtrcs = metrics.SCORERS\n",
    "print(type(mtrcs))\n",
    "\n",
    "for key,value in mtrcs.items():\n",
    "    print(key,'-----',value)\n",
    "print(\"-\"*33,\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T01:31:33.677433800Z",
     "start_time": "2023-09-08T01:31:31.718458900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最好的k值 [13, 18, 20]\n",
      "最好的精度 0.9800000000000001\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from  sklearn.model_selection import cross_val_score\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X,y = load_iris(return_X_y=True)\n",
    "# 交叉验证对参数进行选择\n",
    "k_range = range(1,31)\n",
    "k_accuracy = []\n",
    "for k in k_range: # 轮询设置参数 n_neighbors\n",
    "    knn = KNeighborsClassifier(n_neighbors=k)\n",
    "    accuracy = cross_val_score(knn,X,y,cv=10,scoring='accuracy') # 分类准确度\n",
    "    k_accuracy.append(accuracy.mean()) # 把平均值加入列表对象\n",
    "# 寻找最好的K(超参数)\n",
    "accuracy_Max = max(k_accuracy)\n",
    "# 获取所有等于最好准确率K值索引\n",
    "iIndexs = [idx for idx,x in enumerate(k_accuracy) if x ==accuracy_Max]\n",
    "# 获取所有等于最好准确率的K值\n",
    "best_K = [k_range[idx] for idx in iIndexs]\n",
    "print(\"最好的k值\",best_K)\n",
    "print(\"最好的精度\",accuracy_Max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T01:31:36.664317900Z",
     "start_time": "2023-09-08T01:31:35.886721100Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO29eXxjZ3Xw/z2WF3lsS5rFY3nGmpksk2WSiR0IYSmloUBfQqEB+rZNKFsKDaGEQktfmqb9tXn765LyK6X5tbykLKHQsqVAStqmQICypyQTImeSzGSbTEaesT2eRZL3Tef9497rudZIlmRLlmWd7+fjj6X7PPe5z3Pv1T33Oec854iqYhiGYRjF0lDtDhiGYRi1hQkOwzAMoyRMcBiGYRglYYLDMAzDKAkTHIZhGEZJmOAwDMMwSqJuBYeI7BIRFZHGWju2iNwiIp8sd7+yjnFYRF6Zp+xnReSJZbb7dhH54cp6Z+RCRG4VkX+udj8qiX+MIrJDRMZEJFCorlFe6kZwLPUgXMuIyFUiMuDfpqp/oarvrFafVPUHqnrhah+3FoRO9sNKRLaLyEER+f9FRKrZt/WGqh5R1XZVnV9pWyLyjyLyZ+XoVz1QN4JjNanGLMZYe4jITuD7wD2q+ttaA6ttxcGeCzXGaj9z6uIGEZF/AnYA/+ZObT/oK/51ETkiIidE5A99+zSIyM0i8oyInBSRu0RkU572rxKRARH5fREZAj5d4v7Xi8gBERkVkUMi8i53exvwn8A2t99jIrItx1vtL4nIYyKSFJHvisjFvrLDIvJ7IvKIiKRE5EsiEnTLtojIv7v7nRKRH2Q9NPry7LdoFuQe4w9E5HEROS0in/bq5r8k8nduuwdF5BW+grCIfEpEBkXkqIj8mYgE3DHdAbzYPQ9JETnH/d/g7vtJETnua+ufReT9S7Xrq/sb7jU4LSLfcB/6XpmKyI0i8pRb/tFCswcROQ9HaHxeVT+4RD3vHhl1z98bfGVvF5Efishfu8d9VkSu9pWfIyLfc/e9D9hSoE/XiEhcRNLuMV/tbv+uiPy5iPwImADOFZGXiMiD7jV6UERektWvQ+5xnxWRX3e3n+/2JyXO7+lLefrxdRG5KWtbv4i80f18u4gk3H4+JCI/m6edRSrfQudDRP5FRIbc/n1fRC5xt98A/DrwQffe+jd3+zYR+YqIjLjj/O0lzu0visjDbp8TInJrVvlLReTH7v2aEJG3u9tbReTDIvKc268futvO0jSIT2sizjPgy+49ngbeLiJXisj97jEGReTvRaTZt/8lInKfOL/1YXFU3lERmRCRzb56z3fH3JRvvKhqXfwBh4FX+r7vAhT4BNAK9ALTwMVu+fuB/wZ6gBbgH4Av5Gn7KmAO+Cu3butS+/uO3eh+/0XgPECAn8P58T7P1/ZA1vFuBf7Z/XwBMA68CmgCPgg8DTT7xv0AsA3YBBwAbnTL/hLnYdzk/v0sIEXst6hPbt1HgZhb90fAn+U5V293z9XvuMf8NSAFbHLL/9U9V23AVrcP7/Lt+8Os9o4Az3c/PwEc8l3DI8DlRbT7evecXQw0An8E/Nh3DAX+HYjgvICMAK/OM75bgR8DR4Fbirgvf8U9xw3uuRgHun3jnQV+EwgA7waO+a7R/cDf4NxfLwNGvfsix3GudM/zq9xjbQcucsu+656rS9zxdwGngbe4369zv292z18auNDdtxu4xP38BeAP3faDwEvz9OWtwI983/cASaDF/f5m91iNwAeAISCY497fxeLf0ZLnA/gNoMMt/1sg7iv7R3z3rDuGh4A/BpqBc3Hurf+xxDNgr7vfZcAw8Hq3bIfbl+tw7vnNQJ9b9lH3/G93r/FL3P5dxdm/+8O4zzD3PMzi3LsNOM+c5wMvcs/bLpzf7Pvd+h3AoHs+g+73F7pl9wLv9h3nI8DfLXnfVuMhXo0/8guOHt+2B4Br3c8HgFf4yrrdC9WY56aZ8W7uQvtn3/A52vtX4H2+tpcSHP8PcFfWDX8UuMo37jf7yj8E3OF+/lPga8D5ec5Xvv0W9cmte6Pv+2uAZ/KM7e34Hn6+8/4WnAfWNNDqK7sO+C/fvtmC45+A3wWiOILjQ8CNwDk4D6OGItr9T+AdWedwAtjpfld8D0HgLuDmPOO7FefBmgTOW8Z9Ggeu8Y33aV/ZBrcvUZyH0RzQ5iv/PPkFxz8AH8lT9l3gT33f3wI8kFXnfrc/be7Yftl/Pt06nwU+ju83led4HTgC0ju/fw7cuUT900Bvjnt/l3s+GpdxPiLuvmH3+z+yWHC8EDiStc8fAJ8u8jr+rXe+3f3uzlGnAZj0xpZVdhWFBcf3C/Th/d5x3fv94Tz1fg1XkOMIryHgyqXargtVVQGGfJ8ngHb3807gbnfal8QRBPM4D6FcjKjqlO970fuLyNUi8t/uFDKJ8+BdUu3gYxvwnPdFVTNAAucNptAY/z+cN+1vuqqHm7PazrdfLhK+z8+5/crHUXXv0qz6O3HeyAZ95+0fcGYI+fgezo/sZTiqoe/izNp+DviBez4KtbsTuN1Xdgpn9lfMOczFPcCdwHfEp/LKhYi81VUfece+lMXXfuG4qjrhfmzHOV+nVXXcV/c58hMDnlmi3H/9Ft1Tvra3u8f7NRzhPCgi/yEiF7l1Pohz3h4QR3X6G7kOpKqjwH8A17qbrgU+55WLyAfEURum3HMSpvDvYcnzIY668zZXRZfGeQizRLs7cVTESd+1uYU8v38ReaGI/Jer4knhnB+v7XznfgvO2/9S12Up/NcMEblAHNXzkDvGvyiiD+C8PO4RkXNxZqQpVX1gqQPXk+DQwlUWkQCuVtWI7y+oqkeLbL+o/UWkBfgK8NdAl6pGcKaOng69UL+P4dzkXnuCc5Pk6+eZDquOquoHVPVc4HXA74rP3lAiMd/nHW6/8rHd7Wd2/QTOzGCL75yFVPUSr8s52voejortKvfzD4GfwREc33PrFGo3gaO28l+rVlX9cZFjPwtV/V0c9dZ3RGR7rjquUPkEcBOw2b32j3Lm2i/FILBRHDuYx44l6idw1KF5u+z7vOie8rV9FEBVv6Gqr8KZRR90x4CqDqnqb6rqNuBdwP8RkfPzHO8LwHUi8mIcNct/gePqDfw+8KvARvecpCh8TgqdjzcB1wCvxBFEu9zt+X5nCeDZrHuiQ1Vfk+f4n8d5YYipahhHBSy+tnKd+xPAVJ6ycZwZptNJxx7XmVUnu88fw7keu1U1hCPoCvUB94X3Lhw7z1twZvFLUk+CYxhHT1ksdwB/7r0xikiniFxTgf2bcXSaI8CcOMbPX8jq92YRCec5zl3AL4rIK1xj1gdwHpIFH3oi8lpxDJqCo16Zd/+Ww3tEpEccB4BbgJyGUZetwG+LSJOI/AqObeFeVR0Evgl8WERC4jgYnCciP+fuNwz0+A1+qvoUznT/zThT97Rb75dxBUcR7d4B/IGcMZaG3X6tlJuA7wDfFpFcb6ptOD/+Efe41+PMOAqiqs8B+4D/LSLNIvJSHOGfj08B17v3SYM4bsIX5al7L3CBiLxJRBpF5Ndw7BD/LiJd4jhjtOHcZ2O494yI/IqI9LhtnHbHlu9+uhdHOP0p8CV3ZgiOGmsO55w0isgfA6EynI8Ot78ncR7If5HVRPbz4QEgLY7DS6s7Y7lURF6QpwsdwClVnRKRK3EElcfngFeKyK+653OziPS5Y74T+BtxDPEBEXmx+zL5JBAUx+jehGN3aylwGjpwfsdj7rV9t6/s34GoiLxfRFpEpENEXugr/yyOKvKXgIJrX+pJcPwl8EfutPP3iqh/O84bxDdFZBTH0P3CpXcpfX932v7bOALgNM4Nd4+v/CDO29kht+/bsvZ/Aueh+Xc4bzCvA16nqjNF9HE38C2cH//9wP9R1e+WMEY/n8d5OB9y/5byif+Je+wTOPrt/6mqJ92yt+II08dxzseXcd5swXkIPwYMicgJX3vfA06q6hHfdwEe9tXJ266q3o3j2PBFd4r/KHA1K8RVx70L5yH0LRHZklX+OPBhnHM/jGNc/VEJh3gTzj11CvgTnB9/vr48AFyPY/hM4ZyjnGo091q8Fucl5CSOCuq1qnoC55nxAZxZySmcmd1vubu+APiJiIzh3MPvU9Vn8xxjGvgqzgzg876ib+DYnJ7EUTVNkaWSWYKlzsdn3faO4twD/52176dw1DVJEflXddaGvA7oA57FuVc/iTNbycVvAX/q/tb/GOf37I31CI76+QNu3+I4zjgAvwfsBx50y/4KaFDVlNvmJ90+jwOLvKxy8HvuORjFmQUuvLy5z5lXuWMaAp4CXu4r/xGQAX6qqocLHGfBO8Mwlo2IHAbeqarfqnZfDMNYHiLyHRz38YJRKWyhmmEYRp3jquCeh2MHKkg9qaoMwzCMLETkMzgq6/e7Kq3C+5iqyjAMwygFm3EYhmEYJVEXNo4tW7borl27qt0NwzCMmuKhhx46oarZ60fqQ3Ds2rWLffv2VbsbhmEYNYWI5IxGYKoqwzAMoyRMcBiGYRglYYLDMAzDKAkTHIZhGEZJmOAwDMMwSqKigkNEXi0iT4jI03J2rgdEZKOI3C1OetIHRORSX9nviBPT/1ER+YKcSVu6SZz0h0+5/zdWcgyGYRjGYiomONz48R/FiTK6Byf2/p6sarfgpG+8DCd66e3uvttxIsZeoaqX4mSl8pK+3Ax8W1V3A992vxuGYRirRCVnHFfipL085Ib4/iJnB9Dag/Pw98KH7/LlLWgEWsVJRL+BM4mBrgE+437+DE7OXcMoG08Oj/Kjp08UrlgjZDLKlx48wsTMXFnbvOvBBJMzy03fYtQylRQc21kcR3+Axak4AfqBNwK4yU924uQrPoqTEe8ITmavlKp+092ny03M4yXoyZlWVERuEJF9IrJvZGSkTEMy6oG/uPcA7/n8T1kvcdweOnKa3//Kfr7604JJIYvmgcOn+OBXHuGbjw8VrmysOyopOHKlesz+Jd6Gk+4xDrwXJ/HOnGu3uAY4ByeXcJuIvLmUg6vqx1X1ClW9orPzrBXzhpETVaU/kSQ5McvhkxOFd6gB4keSzv9Esnxtum0dS06VrU2jdqik4BhgcR7qHrLyUKtqWlWvV9U+HBtHJ062rVfi5PsdUdVZnExhL3F3GxaRbgD3//EKjsGoM46cmuD0xCwA/WV80FaT+IAzjnKOx2trOG2Cox6ppOB4ENgtIue4OaKvxZcSFUBEIr780e/kTM7oI8CLRGSDmw/7FcABt949wNvcz28DvlbBMRh1hv+tvJxv6NXEe8g/PTLG6NRsWdscTE2WpT2jtqiY4FDVOeAmnBzCB4C7VPUxEblRRG50q10MPCYiB3G8r97n7vsTnJzQP8XJx9sAfNzd5zbgVSLyFE4O3dsqNQaj/ognkgSbGnj+zo3rQnCcGJtm4PQkP7t7C6qwfyC14jaPp6c4lnJmGkPp6RW3Z9QeFY2Oq6r3AvdmbbvD9/l+YHeeff8EJ+F89vaTODMQwyg7/Ykke7eHed6OjXz6R4eZmcvQ3Fi762S9mcFbXrSTHzx1gvhAkpecv2VFbXoC9dwtbQynTFVVj9TuL8IwyszsfIZHj6Xp7YnQG4swM5/h4FC62t1aEf2JJA0CL929hXO2tJXFztE/kCTQIPz8RVsZGZtmPrM+vM+M4jHBYRguBwdHmZnL0BtzBAfUvp3j4USSC7o62NDcSG9PuCzjiSeSXBTtYNeWNuYzyokxU1fVGyY4DMPF8z7qi0XYFg7S2dFS04LDcy2+fIcjBPtiEYbT0wytQL2UySiPJFL0xSJEQ0EABk1dVXeY4DAMl/iRJJvbmunZ2IqI0NsTqWnB8eyJcdJTc/T2OILjzCzq9LLbPHRijNHpOXpjEaJhR3CsRBAZtYkJDsNw6R9I0heL4HiAw+U7IhwaGSc1WR4X1tWm35tBuTOOPdtCNAWEeGL5nlXevn2xCF3ujMPWctQfJjgMA0hPzfLMyNjCWzmw8KZeDhfWatCfSLGhOcDurR0AtDQG2NMdWpGBvD+RpL2lkfM629nc1kxTQBgywVF3mOAwDBzhoMoiwbG3JwysTLVTTR5OJLl0e5hAw5noP72xCI8MJJftCRV33ZUDDUJDg7C1I2guuXWICQ7D4Iz3VK8rLADCrU2c19m2ItVOtZiem+fAsTSX+wQhOCqm8Zl5nhkZK7nNqdl5DgymFwnXaDhoM446xASHYeCoYM7Z0kZkQ/Oi7b0xx0Bea5FyDwyOMjOfWfSQB1bkZvz4YJq5jNLnFxyhoBnH6xATHEbdo6rEE8lFsw2PvliEE2PTCyE2agXPjpEtOM7Z3EZHsHFZgsOLsusXHF0hZ8ZRa4LVWBkmOIy6Zyg9xfHR6UUPRA9vW61Fyu1PJOnsaGGb6zLr0dAg9MUiyxpP/0CSaCi44IYLEA23MDEzz+h0+ZJEGWsfExxG3ZPv7RzgomiI5saGmlvP4cygzrgW++ntiXBwaJSp2dKy9/UnkvTGFs/KFlxya2xGZqwMExxG3fNwIklTQNizLXRWWXNjA5dsC9WU4EhNzHLoxPjCivFs+mIR5jPKo0eLN/qfHp/h8MmJs4Rrd7gVwAzkdYYJDqPu6U8k2dMdoqUxkLO8tyfC/oEUc/OZVe7Z8njkqOchlltwXBbz3IyLF4b9A2fbNwALO1KnmOAw6pr5jLJ/IJVTTeXRF4swOTvPU8dLd2GtBp4Re28OYz/A1o4g2yOtJQmOeCKJCOzdvrjNraEWwFRV9YYJDqOuefr4GOMz8zkN4x61ZiDvH0hyXmcb4damvHX6YpGFWURRbSaSnN/ZTkdwcZvBpgAbNzSZqqrOMMFh1DVLGcY9dm7eQLi1qSbsHAuuxUuMB6A3FiZxapKTRYREV1X6B1J5hWtXKGjxquoMExxGXfNwIklHsJFzNrflrSMiCwsB1zpHk5OcGJtZcgYFZ+wfxcw6EqcmOTU+k1cY2erx+sMEh1HX9CeciLgNDWe7rfrpi0V4cniUiZm1vV6h3xe9din29oRpEIoKpxLPYxj36A7b6vF6wwSHUbdMzszzxPBoXu8jP32xMBld+5Fy44nTNDc2cFH0bNdiPxuaG7mgq6Mou01/IklLYwMXRjtylneFgpwYm2Fmrja8zoyVY4LDqFsePZZiPiv2Uj5KUe1Uk/5Eiku2OYsWC3H5DsdAXihcSNyNstsUyN2m55J7fNRmHfWCCQ6jbvHeti+L5XZb9bO5vYXYptYFVdBaZG4+w/6jqaJmUOAIw+TELM+dnMhbZ3Y+w6NH8xvGAbrCltCp3jDBYdQtDyeSbI+0srUjWLgyrPlUsk8OjzE5u7RrsR/P2L3ULOqJoVGm586OsuvHm3EMpQp7aBnrAxMcRt3iGcaLpS8W4Whycs2qZPKt7s7HBV0dbGgO8PCR/ILDE5TZeT38dIe91eOTxXbVqHFMcBh1yYmxaQZOT54VtG8pziwEXJvqqviRJOHWJnZu3lBU/UCDcOn28JIzjv5Ekk1tzfRsbM1bJ9zaREtjg6mq6ggTHEZdsrDwr0h7AMAl25yUqWt1BXn/gLPwL1dE3Hz0xSI8diyd1yPKy1OyVJsi4q7lMFVVvWCCw6hL+hNJGiR/PKdctDYHuCjasSY9q8an53hyeLQk1Rs4gmNmLsPBofRZZaNTszw9MkZfbGPBdrpClnu8njDBYdQl8YGUq+NvLGk/bwV5JrO2Mt7tP5oio856k1LoXSIO1/6jKVQpSp0XDdnq8XqiooJDRF4tIk+IyNMicnOO8o0icreIPCIiD4jIpe72C0Uk7vtLi8j73bJbReSor+w1lRyDsf5QVfoTybz5KpaiLxZhdGqOZ0+OV6Bny2c5qjeAbeEgnR0tPJxDcMRLaNMLO2IpZOuDigkOEQkAHwWuBvYA14nInqxqtwBxVb0MeCtwO4CqPqGqfaraBzwfmADu9u33Ea9cVe+t1BiM9cnhkxOkJmdLfsjC2o2U2z+QJLaplc3tLSXtJyL09uROJdufSLJr8wY2tjUXbCcaCjIzl+H0xGxJxzdqk0rOOK4EnlbVQ6o6A3wRuCarzh7g2wCqehDYJSJdWXVeATyjqs9VsK9GHVFMRNx8nNfZTltzYM2t54gfSS5LEIKj3npmZJz01OKHfn9i6Twlfrw85Bazqj6opODYDiR83wfcbX76gTcCiMiVwE6gJ6vOtcAXsrbd5Kq37hSRnJY7EblBRPaJyL6RkZHljsFYh8QTSTY0B7igK3fspaUINAiX5XlDrxbH01McS02VbBj38Izfj/jcjIdSUwyli29zIfe42TnqgkoKjlz+e9kK0NuAjSISB94LPAwshB8VkWbgl4B/8e3zMeA8oA8YBD6c6+Cq+nFVvUJVr+js7Fz2IIz1hxd7KVAgIm4+emMRHh9MMzU7X+aeLQ9v9rNcweF5lvm9xeIlzsoWZhwmOOqCSgqOASDm+94DHPNXUNW0ql7v2jLeCnQCz/qqXA38VFWHffsMq+q8qmaAT+CoxAyjKKbn5nn8WHrZD1lwVDuz88qBwbNdWKtB/0CSQINwybbSPKo8wq1NnNvZtmgFeTyRpCkg7OleOsqux9aOFkRMVVUvVFJwPAjsFpFz3JnDtcA9/goiEnHLAN4JfF9V/b/G68hSU4lIt+/rG4BHy95zY91ycHCUmfnMCgWHo9pZK+qq/kSKi6IdtDYHlt1Gn+tm7HlF9SeSXNwdIthUXJtNgQa2tLeY4KgTKiY4VHUOuAn4BnAAuEtVHxORG0XkRrfaxcBjInIQZ3bxPm9/EdkAvAr4albTHxKR/SLyCPBy4HcqNQZj/eGpY5ZjGPeIhoN0hVrWhIE8k3Fci1cyHnAEx4mxaQZTU8xntKQoux62lqN+KG31U4m4rrL3Zm27w/f5fmB3nn0ngM05tr+lzN006oj4kSSdHS1sCxcXETcffbEI/WsgqdOhE+OMTs+taAYFZ+wj8USS87e2MzY9V7Iw6goFGTidP0S7sX6wleNGXREfcNxWS4nnlIveWIRnT4yTnJgpU8+WR/8KDeMeF0VDNAca6E8kl21sj4ZbbMZRJ5jgMOqG1OQsh0bGSw7LkYu+hYyA1Z11xBNJ2poDnNfZvqJ2mhsb2LMtRDyRpD+RpCPYyLlb2kpqIxoKkpyYXTPeZkblMMFh1A2PLOSrKBy0rxB7e8KIVN9A3j+Q5LKeyLJdi/30xSLsP5rioedO09sToaHENrtCtgiwXjDBYdQN3kO+lIi4+egINnF+Z3tVDeRTs/McGEyv2DDu0ReLMDEzz8Gh0ZLylHh0h52cHaauWv+Y4DDqhngiybmdbYRbm8rSXm/MWUFercB+jw+mmZ3XsqjeYLGn2XLCl0TDTpwsWz2+/qmoV5Vh+FFVVClZBVKuY8cTKV52wZaytdkXi/DlhwZ49Gh6YeX0anL/Myfdfqxc9Qawa/MGwq1NpCZnl2VsX01VVSajiLBiJwdjeZjgMFaNv/r6E9z/zAm+dtNLV/3Yx1JTnBibXnYgwFx4Ydlf9/c/LFubpRINBcsmtESEy3dEeGp4jK2h0tvsCDbR1hxYFVXVH33tUQaTk3z6egscUQ1McBirxnefOM7BoVFOjc+wqYhQ3eUkfqQ8bqt+9nSH+Ps3XV7VUOKXbisuJEix/L/XXMro1FzhinnoCgdXRVX13YPHmZm33B/VwgSHsSpMzDipTcHxBHr5hVtX9fj9A0maAw1cXGTspWIQEV572baytbcWiG3asKL9u8NBBiusqvKiAYvA7HyGpoCZalcbO+PGqvDo0TRettVquLDGE0n2bAvR3Gi3fCVZjdzj3toZVTg+Ol3RYxm5sV+RsSrEE6cBRye/2i6sc/MZ9g+kyqqmMnITDQU5Pjpd0Zzs3r0EtmakWpjgMFaF/kSK2KZWXnbBllV3YX3q+BiTs/MmOFaBaDjIXEY5MV65mUB/IsUGNxKwCY7qYILDWBXiCSdGVG8swumJWY6cWr1geCtJFWuUxkImwFRlBIcXDdizkdliw+pggsOoOMdHpzianKQvFlkUhXW1iCeShFub2LV5ZYZfozBRV3AMpiYr0r4XDfjnLuykubHBFhtWCRMcRsXxcln3xSJc0NVBsKmB/sTqBQeMu/kqbLFY5ekOVzb3uDd7vDwWcfJ/mKqqKpjgMCpOPHEmtWlToIFLt4UXGTgryfi04wbcV4b4VEZhNre3EGiQiqmQ4okk7S2NnNvZTjRsiaOqhQkOo+L0DyQXpTbti0V49Fia2flMxY/96NEUGYW+HWbfWA0CDcLWjhaGKmTjcKIBhwk0iM04qogJDqOi5Ept2huLMDOX4Ymh0YoffyFVbBlDjRhL0xWqzOrx7GjA3oyjWkEm6xkTHEZFefbkOOmpxalNvc8Pr4KBPJ5IEtvUyub2loofy3CIhoIVMY570YC9l4CuUJCZuQzJKoZ8qVdMcBgVJVdq056NrWxua16VFeT9iZTNNlaZaDjIcLr8qqoFw7irdvQ8uMzOsfqY4DAqSq7UpiJCbyxScZdcvxuwsXpEw0HGpucYm15+sMRcxBNJoqHgwloRL/+HCY7VxwSHUVH6E7lTm/bFIjwzMkZ6qnJqhn6fG7CxekQrlJfDsZWd8Y6LehkHzUC+6pjgMCrG9Nw8j+dJbdobi6AKjw5Ubj1Hv88N2Fg9FlaPl3EmkJyY4fDJiUVJq7Z2tCBigqMamOAwKsbjx/KnNu1111VU0kDeP5Dkwq4zbsDG6uAllipnePX4QtiYM/dSU6CBzW0ttnq8CpjgMCrGGcP42alNIxuaOWdLW8UM5JmMEk8kbf1GFYhWYMbRn0ghAnu3L34JiYZbzMZRBUxwGBUjnkjSFWrJm9q0tydMvEKRcp89Oc7o1Bx95lG16rQ2Bwi3NpVVhRRPnGb31nY6gk2LttsiwOpggsOoGP0FcmD0xSIcH52uyBvjQqpYm3FUhWiofOFAVJX+gdxu1RZ2pDqY4DAqQnJihmdPjC8Zytwrq4S6qn/gbDdgY/UoZ+7xgdOTnBqfyXkvRUNBkhOzTM3Ol+VYRnFUVHCIyKtF5AkReVpEbs5RvlFE7haRR0TkARG51N1+oYjEfX9pEXm/W7ZJRO4Tkafc/2cr0I2q4+JweVgAACAASURBVKX3XEpVdHF3iKaAVMRA3p9IsteNaWSsPtFQS9lUSA/nWETqUQkPLqMwFRMcIhIAPgpcDewBrhORPVnVbgHiqnoZ8FbgdgBVfUJV+1S1D3g+MAHc7e5zM/BtVd0NfNv9bqwx+hNJx5i5RFTaYFOAPd2hss84pmYdN+BcRnljdYiGgoyMTZclkGV/IklLYwMXRjvOPk64MmtGjKWp5IzjSuBpVT2kqjPAF4FrsurswXn4o6oHgV0i0pVV5xXAM6r6nPv9GuAz7ufPAK+vROeNldGfSHJ+59nGzGx6YxH2D6SYL2OO6gOD+d2AjdUhGm5FFUZGVx56pD+R5NLtTkj+s45jYUeqQiUFx3Yg4fs+4G7z0w+8EUBErgR2Aj1Zda4FvuD73qWqgwDu/625Di4iN4jIPhHZNzIysuxBGKWjqgvJkwrR2xNhfGaep4+Ple34liq2+pQrHMjsfIb9R/M7WXTZjKMqVFJw5FIuZ79W3gZsFJE48F7gYWAhwI2INAO/BPxLqQdX1Y+r6hWqekVnZ2epuxsrYOD0JCfHZ4oK9eF5PZVTXeW5AXe7ISmM1edM7vGVPdCfGBplei6T9yWgo6WRtuaAzThWmUoKjgEg5vveAxzzV1DVtKpe79oy3gp0As/6qlwN/FRVh33bhkWkG8D9f7wSnTeWT3wJY2Y252xuoyPYWFYDeT7XTWP1KJcKybuXLs9zL4lIWT24jOKopOB4ENgtIue4M4drgXv8FUQk4pYBvBP4vqqmfVWuY7GaCreNt7mf3wZ8rew9N1bEUsbMbBoahL5YpGwzDs8N2NZvVJdNbc00BxpWrELqTyTZ1NZMz8b8s0dbBLj6VExwqOoccBPwDeAAcJeqPiYiN4rIjW61i4HHROQgzuzifd7+IrIBeBXw1aymbwNeJSJPueW3VWoMxvLoH8hvzMxFb0+EJ4ZHmZxZuS9+MW7ARuUREbaGVh4OpH8gSW9PGJH8btXRUGXyfxj5aSymkoh8BbgT+E9VLdq/TlXvBe7N2naH7/P9wO48+04Am3NsP4njaWWsQTxj5puu3Fn0Pr2xCPMZ5dFjKV6wa9OKjl+MG7CxOnSHVzYTGJ2a5anjY/zi3m1L1vNUVZmM0mDrdlaFYmccHwPeBDwlIreJyEUV7JNRwzw5PMrUbKYkVZEX8bQc6qpi3YCNyrPS3OP7j6ZQXRwRNxfd4SBzGeXEuM06VouiBIeqfktVfx14HnAYuE9Efiwi14uI/UKNBRYM4yWoirZ2BNkeaV2xgbwUN2Cj8njxqpYbxHIhlHqBe+mMB5cJjtWiaBuHiGwG3o5jxH4YZ5X384D7KtIzoybxjJmxTaW5wvbGwiuecXhuwCY41gbRcJCp2QypyeVleexPJNm1eQMb25qXrGeLAFefogSHiHwV+AGwAXidqv6Sqn5JVd8LWBQ5Y4H+RKqgMTMXfbEIA6cnOTG2/LfGQq6bxurStcIHen8iVdRLwELYERMcq0axM46/V9U9qvqX3qptD1W9ogL9MmqQsek5njw+uqw3fk8dsZJZRyluwEbl6V7Bqu6h1BRD6ami1uNsaW8h0CArXmxoFE+xguNiEVm4gm5U29+qUJ+MGmX/gGPMLGbhXzZ7e8I0yAoFR4luwEZlWUnk2gVbWRFOFoEGobO9paypao2lKfYX9puquvCLVtXTwG9WpktGrdI/UJwxMxcbmhu5oKuDuLsOo1Q8N2BbMb52WFBVLcNo3T+QpLFB2NMdKqp+1FaPryrFCo4G8Smt3ZDpS1usjLojfiTJziKMmfnwVpAvxwvHcwMu5LpprB7NjQ1sbmtelu0hfiTJxd0hgk2BouqXM+OgUZhiBcc3gLtE5BUi8vM4YUC+XrluGbVI/0ByWWoqj75YhNTkLIdPTpR+7IQzU7nccnCsKbpCQYZSkyXtM5/RJSPi5iIaDpqNYxUpVnD8PvAd4N3Ae3ByaHywUp0yao/h9BSDqeKMmfnwjOrxxOmS940nTrNxQ1PJbsBGZekOBxkqMRzIMyNjjE3PleRk0RUKMjo9x9j0XOHKxoopdgFgRlU/pqr/U1V/WVX/QVUtya+xQLwMOTB2b22ntSmwMHsoBc91s1Q3YKOyLCdybSnRlT0W8n/YrGNVKHYdx24R+bKIPC4ih7y/SnfOqB36E44x85JtxRkzc9EYaGBvT3jhwVEsnhvwStRkRmWIhoKcGp9heq7498z+RJKOlkbO3dJWwnGcmaYZyFeHYlVVn8aJVzUHvBz4LPBPleqUUXvEE6UZM/PRF4vw+LF0SQ8azw3YVoyvPbxV3cdLUFfFE0kui4VLClhoucdXl2IFR6uqfhsQVX1OVW8Ffr5y3TJqiUxGeWSgNGNmPvpiEWbmMxwcHC16H88N2EKprz281K7FrrGYmp3n4FDps0cLO7K6FCs4pkSkASc67k0i8gby5Po26o/lGDPzccZAXry6aqVuwEblKPWB/ujRFPMZLdnJorU5QCjYaKqqVaJYwfF+nDhVvw08H3gzZ7LwGXXOGWPmytdQbAsH2dLeUtIKcifZj8021iKeCqlYV9nlGMb9x7LV46tDwURO7mK/X1XV/wWMAddXvFdGTdE/4BkzVx7vUsRJJRsfKE5weG7AZhhfm4SCjbQ2BYqecfQPpNgWDrLVnamUwkrzfxjFU3DG4brdPl/Mz9HIw3KMmUvRFwtzaGSc1EThcNzlcAM2KoeIEA0Xv6o7nji97Gu50oyDRvEUlToWJ//G10TkX4Bxb6OqZucDNwrw34dO8tn7D7PM3DZrkoODo9zwsnPL1p734Hj35x4i3Lp0nrBnT4yv2A3YqCxdoRb++5mTvPufH1qyniokTk3y6y8sPu2wn2goyImxaebmMzQuI9Dltx4fJjU5yy8/v2dZx8/FfY8PMzEzxzV928vW5lqgWMGxCTjJYk8qBUxwlMgXHzjCtx4/zq4tG6rdlbJxQVcHr9nbXbb2nr9zIy86dxMnxqaLys/xphfuWLEbsFE5XnvZNj57/2GeGRkrWHfv9jCv2tO1rON0hYNkFEbGpukOlx5B4CPfepLh9BRvfN72si0k/Zv7nmR6dr4+BYeqml2jTAympuiNhfmXG19S7a6sWTY0N/LFG15c7W4YZeLNL9rJm1+0vFlEKXgeXIOpqZIFh+cGPJ9RjiYn6dm48he7iZk5nhwepaWxAVVdV1ENihIcIvJpnBnGIlT1N8reo3XOcHqKveYBZBhl50zu8dLtHJ4bMDh2s3IIjkePppnPKBMz84xOzxEKLq12rSWKVQT+O/Af7t+3gRCOh5VRAqrKUHqKaKil2l0xjHVH9wpSyHpOFo0NsqJkYn787ay3yL3Fqqq+4v8uIl8AvlWRHq1j0pNzTM1mFt6MDMMoH5vammkONCxLcHhuwF3h4LKCbObC71I+lJ5id9f6SWm83Bybu4Ed5exIPeDd0N6iKMMwyoeIsDXUsqy3+3jiNH07IvTFIuw/mmJuPrPi/sSPJNm73VkUu97chIuNjjsqImnvD/g3nBwdRgkMugltojbjMIyKEA2Vvnr85Ng0iVOT9PY4gmNydp4nh1emiR8ZneZocpL/cYnjIbbeBEexqqr1M8eqIt6qVlNVGUZl6AoHeexoaaqmR9w8972xyMJLXTyRZM8K1gZ59o0XnruZyIamdRd8sdgZxxtEJOz7HhGR11euW+uToZSzJsEEh2FUBi/3eCl56x9OJGkQZw3Jzs0biGxoWrGBvH8gSaBBuHRbmOg6DIVSrI3jT1R1QYyrahL4k0I7icirReQJEXlaRG7OUb5RRO4WkUdE5AERudRXFnGTRx0UkQMi8mJ3+60iclRE4u7fa4ocQ9UZSk+xpb2Z5sblmpYMw1iK7nCQqdkM6cniU8j2J5Jc0NVBW0sjIkJvT2QhVP9yiSeSXNjVQWtzwMm7XqeCI1e9JdVcbnDEjwJXA3uA60RkT1a1W4C4ql4GvBW43Vd2O/B1Vb0I6AUO+Mo+oqp97t+9RY6h6gynp2y2YRgVpKvEMO6qSv9AclGQzL5YhCeHRxlfZv7yTEbpTyQXQuc4MbRKy7u+1ilWcOwTkb8RkfNE5FwR+QiwdOAZuBJ4WlUPqeoM8EXgmqw6e3DWhaCqB4FdItIlIiHgZcCn3LIZd5ZT0wympswwbhgVJFriWo7nTk6QnJhdFFixLxYho7C/RFuJx+GT46Sn5hbSDHSFgpwcn2ZmbuWeWmuFYgXHe4EZ4EvAXcAk8J4C+2wHEr7vA+42P/3AGwFE5EpgJ9ADnAuMAJ8WkYdF5JMi4k9AfJOr3rpTRDbmOriI3CAi+0Rk38jISFGDrDTD6amFjGiGYZSfhcRRrgdjITyVlD+fy2U9zgN/uXaOhYyUMefRFA0HUYXjo+tHXVWU4FDVcVW9WVWvcP9uUdXxArvlCsySbbG6DdgoInEc4fQwTl7zRuB5wMdU9XKciLyejeRjwHlAHzAIfDhPnz/u9bezs7OIUVaW6bl5To3P2IzDMCrIVjcqQ7GqoYePJGltCnBB15lcMpvbW9ixaUNJWSj9xI8kaWsOcP5Wp03vN7+eDOTFelXdJyIR3/eNIvKNArsNADHf9x7gmL+CqqZV9XpV7cOxcXQCz7r7DqjqT9yqX8YRJKjqsKrOq2oG+ASOSmzNczzt3Mi2+M8wKkdLY4DNbc0lJI5yFullh2HvjUWWPeOID6TY2xMm4OanWbC7rCM7R7Gqqi1+G4OqnqZwzvEHgd0ico6INAPXAvf4K7ieU16i6HcC33eFyRCQEJEL3bJXAI+7+/jjd78BeLTIMVSVhVXjNuMwjIpSbCbAmbkMjx1L05sj5XFvT5hjqSmOlzhLmJ6b58Cx9CKbyUpiaK1Vis3HkRGRHap6BEBEdpEjWq4fVZ0TkZuAbwAB4E5VfUxEbnTL7wAuBj4rIvM4guEdvibeC3zOFSyHOJOy9kMi0uce/zDwriLHUFW8laM24zCMyhItMhPgwaE0M3OZBVuEn8t3OA/+eCLJL1wSLfrYBwZHmZnP0OezmUQ2NNHc2LCuVFXFCo4/BH4oIt9zv78MuKHQTq6r7L1Z2+7wfb4fJ+5Vrn3jwBU5tr+lyD6vKbwb2dxxDaOydIWCRdkn+hfSDp8947hkm6Nq6h8oTXB4bfbtOCM4RGRZoVDWMsUax7+O8xB/Asez6gM4nlVGkQylp2htChAKFiurDcNYDtFQkFPjM0zPzS9ZL55IsaW9me2Rs5M+BZsCXBTtKNlAHk8k2drRcpZKOhoKrqvQ6sUax9+Js97iA+7fPwG3Vq5b64+h9BTd4eC6ygJmGGuRaNjxrPIcUvIRT5ymLxbJ+5vsi0V4JJEikyk+fIm38C+7za7w+lo9Xqxx/H3AC4DnVPXlwOU46yyMIhlO2apxw1gNom7a2KUe1OmpWZ4ZGV+0fiOb3liE0ek5Dp0otPLAITUxy6ET44tWoXt0h0uPobWWKVZwTKnqFICItLirvC8ssI/hYyg9ZYZxw1gFziwCzC849rsRcf22iGwuj50xkBfDmYV/Z7fZFQoyM5chOTFbVFtrnWIFx4C7juNfgftE5Gtkrckw8pPJqMWpMoxVohjB4QmDy7bnFxzndrbT3tJY9HqO/kQSEdjbc7axPVpiDK21TrH5ON7gfrxVRP4LCANfr1iv1hmnJmaYnVfLNW4Yq0CotZFg09IpZOOJJOduaSO8oSlvnUCDsHd7uOhIuf0DSc7rbCcUPLtNz+4ylJri4u7l5/lYK5Qc31tVv6eq97iBC40isDUchrF6eO6v+QSHqhJPJHOqlLLp2xHhwGCaqdmlPbS8NvPZTEqN2rvWscQQq8DwQq7xs93+DMMoP9FwfvfXwdQUI6PTi1Z356O3J8LsvPL4YHrJekeTk5wYm1mIiJvN1o7C6rNawgTHKmDhRgxjdVlqxnFm4V8RMw7PQH5kaXWVZzPJtQodoLmxgS3tLetm9bgJjlVgODVFg8CW9ubClQ3DWDFdYSdeVa41GPFEkuZAAxd3dxRsJxoOEg0FC9o5+hNJmhsbuDCav81ouMVUVUbxDKam6OxoOSsCp2EYlSEaCjI7r5yaONsUG08kuXhbiJbGQFFt9cbCBT2r+hMpLt0WWjItdDRUXAytWsCeZKvAUNoy/xnGapLPJXc+o+w/mlpYo1EMfbGNHD45wenx3P5Ac/MZ9h9NFVR9rafc4yY4VoFhW/xnGKuKl2kz26bw1PFRJmbmcwY2zIdXN5+66snhMSZn5wt6aUVDQZITswU9tGoBExyrwJDlGjeMVSVfDowFw/gSoUay2bs9jIijjsrFUivG/UTzCLNaxARHhZmYmSM9NWe5xg1jFelsb6FBzlZVxRMpQsFGztnSVnRbHcEmdm9tJ544nbM8fiRJZEMTOzZtWLIdT3CsBzuHCY4Ks7D4z2YchrFqNAYc99ezBUfu6LWF6O2J0D+QyhmksH/AWfhXqM31FHbEBEeFsTUchlEdolmhzCdm5nhyeLSoFePZ9MYinBqfIXFqcRqi8eni2+yyGYdRLJ4+01RVhrG6ZOcef+xYmvmMLktwLCwEzDKQ7z+aIqOF7RsAHS2NbGgO2IzDKMxQykkmYzMOw1hdurNyj3urv4tZMZ7NhdEOWhobzlrP4X2/LEdE3GxExAmFYoLDKMRweoqOYCNtLZYy1jBWk65QkPTUHBMzc4AzW+jZ2MqW9tKjVDcFGti7PXxWbo54IsmOTRvYXGSb62URoAmOCmOuuIZRHbIXAXppXZdLbyzCo0dTzM5nFraV2mY0FGS4QErbWsAER4UZtMV/hlEVor61HCfGphk4PUlfCes3sumNRZiey/DE0CgAx9NTHEtN0VuEmspjqRhatYQJjgpjucYNozp4v7vh9NSCLWKpVLGFyE4l6/2/vIQ2o6EgcxnlxHhtzzpMcFSQ+YwyMjZtqirDqAJnFtxNE08kCTQIl2xbfva9no2tbGprXhBC/QNJGhuES7YVP+NYWD2eMsFh5OHE2DTzGTVVlWFUgfaWRjpaGhlOTxFPJLmgq4MNzct3UhERenvCi2YcF3V3EGwqLsourJ9FgCY4KoitGjeM6tIVDnIsOUl/kaliC9EX28jTI2OkJmd5JJEqKeYVLLa71DImOCrIoOUaN4yqEg0F2ffcadJTc3nTupZCbyyMKtzTf4zR6bmSvbS2tLcQaJC8aW1rBRMcFWRh1bjNOAyjKnSFgpxy82jkS+taCt6s5bM/PgxQUl4PgECD0NnesvBSWatUVHCIyKtF5AkReVpEbs5RvlFE7haRR0TkARG51FcWEZEvi8hBETkgIi92t28SkftE5Cn3/8rvhgoxlJ6iKSBsbrOUsYZRDaJhZ2HehuYA529tX3F7kQ3N7Nq8gaeOj9He0si5naW3uR5Wj1dMcIhIAPgocDWwB7hORPZkVbsFiKvqZcBbgdt9ZbcDX1fVi4Be4IC7/Wbg26q6G/i2+31NMpyaYmtHkIaG0iJxGoZRHqLhVsDJqREo0+/QU08tt83oOsgEWMkZx5XA06p6SFVngC8C12TV2YPz8EdVDwK7RKRLRELAy4BPuWUzquqt9b8G+Iz7+TPA6ys1gGPJSe5/5uSy9x+yxX+GUVU8x5SVrN/IxlNXLbfNaDhoNo4l2A4kfN8H3G1++oE3AojIlcBOoAc4FxgBPi0iD4vIJ0XEy7zSpaqDAO7/rbkOLiI3iMg+Edk3MjKyrAH83Xee4l3/tC9nDP5isFzjhlFdvIRNLzpnc9navPKcTYv+l0pXKMjo9Bzj03Nl69NqU0nBkWsOl/0Evg3YKCJx4L3Aw8Ac0Ag8D/iYql4OjFOiSkpVP66qV6jqFZ2dnSV3HpzkLempOZ49MV7yvqrKkK0aN4yqcv7Wdr73v67iqguX9wzIxSXbwk6bFyyvTc/uUsvqqkoKjgEg5vveAxzzV1DVtKper6p9ODaOTuBZd98BVf2JW/XLOIIEYFhEugHc/8crNQBvKpovSf1SjE7PMTEzv3CTGIZRHXZubis5418l24yGHLtLLUfJraTgeBDYLSLniEgzcC1wj7+C6znluRy9E/i+K0yGgISIXOiWvQJ43P18D/A29/PbgK9VagC7t3awoTmQN0n9Ung6TJtxGIbhZz3kHq9YkghVnRORm4BvAAHgTlV9TERudMvvAC4GPisi8ziC4R2+Jt4LfM4VLIeA693ttwF3icg7gCPAr1RqDIEG4dLtYR5OlD7j8Kah3a5Xh2EYBqyPsCMVzS6kqvcC92Ztu8P3+X5gd55948AVObafxJmBrAqXxyJ8+keHmZ6bp6Wx+Jg0Fm7EMIxctDYHCAUba3oth60cL0BvLMLMfIaDg6Ml7ecJjq0hs3EYhrGYaLi2MwGa4ChAb1YM/mIZSk+xcUNTSZEzDcOoD7pCtb163ARHAbaFg3R2tJyVpL4Qw2lzxTUMIzfd4WBNx6sywVEAJwZ/ZFkzDls1bhhGLqKhICfGppnz5S+vJUxwFMHlOyIcOjFOamK26H2GUtN0m+AwDCMHXeEgGYWRsdrMBGiCowi8ZC2PHC1u1jEzl+Hk+LSpqgzDyMmCS26NqqtMcBTB3h4nAUz8SHGC4/joFKrmimsYRm68l8paNZCb4CiCcGsT53W2FR16ZCGBk6mqDMPIgafGrlUDuQmOIumNRYgnUkVFyh1KOXpLm3EYhpGLTW3NNAcaanb1uAmOIumLRTgxNs3R5GTBumfCjZjgMAzjbESEraGWms3LYYKjSLzkLcUEPBxOT9HS2EC4tanS3TIMo0ap5UyAJjiK5KJoiObGBuKJ0wXrDqacNRzlDuVsGMb6oSscZDht7rjrmubGBi7ZFipuxmEJnAzDKEB3yIlXtdwMo9XEBEcJ9PZE2H80VXC1p6WMNQyjENFwkMnZedKTtZdC1gRHCfTFIkzOzvPk8FjeOqpq4UYMwyhIVw3n5TDBUQILBvIl1nMkJ2aZmcvYjMMwjCVZyARogmN9s3PzBsKtTUtGyvVuAptxGIaxFN7LZS265JrgKAERcRcCLiE4LNe4YRhF4CV5sxlHHdAXi/Dk8Cjj07kNWjbjMAyjGFoaA2xuazbBUQ/0xcJkFPYfze2WO5SaQgS2dljKWMMwlqYrVJspZE1wlIgXYj2fnWM4PcWW9haaAnZqDcNYmlrNPW5PtxLZ3N5CbFNrXs8qW8NhGEax1GrucRMcy6C3J5I3N8eQrRo3DKNIusNBTo7PMD03X+2ulIQJjmXQF4twLDXF8RxvCs7iP7NvGIZRGE87cbzGYlaZ4FgG3kLAbLfcqdl5khOzpqoyDKMoump0EaAJjmVwybYwgQY5y86xkPnPBIdhGEVQq7nHTXAsg9bmABdFO86KlOtd/O5wazW6ZRhGjRGt0dzjJjiWSW8sQn8iSSZzJiTymcV/ZuMwDKMwodZGWpsCNuPwIyKvFpEnRORpEbk5R/lGEblbRB4RkQdE5FJf2WER2S8icRHZ59t+q4gcdbfHReQ1lRxDPvpiEUan5zh0Ynxhm4UbMQyjFETEWcthMw4HEQkAHwWuBvYA14nInqxqtwBxVb0MeCtwe1b5y1W1T1WvyNr+EXd7n6reW4n+F+JMKtkzdo6h9BRtzQE6gpYy1jCM4ugKtZiqyseVwNOqekhVZ4AvAtdk1dkDfBtAVQ8Cu0Skq4J9KhvndbbT1hxY5Fk1nJ5a8JIwDMMohmgoyKCpqhbYDiR83wfcbX76gTcCiMiVwE6gxy1T4Jsi8pCI3JC1302ueutOEdlY/q4XJtAgXNYTWeRZNZSyVeOGYZRGVzjI8fR0TaWQraTgkBzbss/MbcBGEYkD7wUeBrywsz+jqs/DUXW9R0Re5m7/GHAe0AcMAh/OeXCRG0Rkn4jsGxkZWdlI8tAbi3BgMM3UrLPqczg9bVFxDcMoiWgoyMx8hlPjM9XuStFUUnAMADHf9x7gmL+CqqZV9XpV7cOxcXQCz7plx9z/x4G7cVRfqOqwqs6ragb4hLc9G1X9uKpeoapXdHZ2lndkLn2xCLPzyuODaTIZZdjiVBmGUSLdNbgIsJKC40Fgt4icIyLNwLXAPf4KIhJxywDeCXxfVdMi0iYiHW6dNuAXgEfd792+Jt7gba8GfgP5ifFp5jJqMw7DMEqiqwbXcjRWqmFVnRORm4BvAAHgTlV9TERudMvvAC4GPisi88DjwDvc3buAu0XE6+PnVfXrbtmHRKQPR+11GHhXpcZQiGg4SFeohXgiyRU7NwHmimsYRml4L5u1ZCCvmOAAcF1l783adofv8/3A7hz7HQJ687T5ljJ3c0X0uQsBFxb/meAwDKMEOttbaJDayj1uK8dXSG8swuGTEzwxlAbO6CsNwzCKoTHQwJb2FrNx1BN9bkbAbzw2TKBB2Nxu4UYMwyiN7nCQoRoKrW6CY4Xs7Qkj4uQg39rRQqAhlxeyYRhGfrpCQVNV1RMdwSbO72wHzDBuGMbyqLV4VSY4yoDnlmuGccMwlkNXKEhqcpbJmdpIIWuCowz0eoLDDOOGYSyDhYRONTLrqKg7br3gzThMVWUYxnLwvDHfeudPCDYGytr2X7xxLy/YtamsbZrgKAMXd4d478+fz2sv6y5c2TAMI4u+HRF+9YoexqbnClcukdam8goiAKmliIzL5YorrtB9+/YVrmgYhmEsICIP5ciHZDYOwzAMozRMcBiGYRglYYLDMAzDKAkTHIZhGEZJmOAwDMMwSsIEh2EYhlESJjgMwzCMkjDBYRiGYZREXSwAFJER4LmszVuAE1XoTqVYb+OB9Tem9TYeWH9jWm/jgZWNaaeqdmZvrAvBkQsR2ZdrRWStst7GA+tvTOttPLD+xrTexgOVGZOpqgzDMIySMMFhGIZhlEQ9C46PV7sDZWa9jQfW35jW23hg/Y1pvY0HKjCmurVxGIZhGMujnmcchmEYxjIwwWEYhmGURN0JDhF5tYg8ISJPi8jN1e5P/qKPSQAAA+tJREFUORCRwyKyX0TiIlJzGatE5E4ROS4ij/q2bRKR+0TkKff/xmr2sVTyjOlWETnqXqe4iLymmn0sBRGJich/icgBEXlMRN7nbq/J67TEeGr5GgVF5AER6XfH9L/d7WW/RnVl4xCRAPAk8CpgAHgQuE5VH69qx1aIiBwGrlDVmly4JCIvA8aAz6rqpe62DwGnVPU2V8BvVNXfr2Y/SyHPmG4FxlT1r6vZt+UgIt1At6r+VEQ6gIeA1wNvpwav0xLj+VVq9xoJ0KaqYyLSBPwQeB/wRsp8jeptxnEl8LSqHlLVGeCLwDVV7lPdo6rfB05lbb4G+Iz7+TM4P+qaIc+YahZVHVTVn7qfR4EDwHZq9DotMZ6aRR3G3K9N7p9SgWtUb4JjO5DwfR+gxm8WFwW+KSIPicgN1e5MmehS1UFwfuTA1ir3p1zcJCKPuKqsmlDrZCMiu4DLgZ+wDq5T1nighq+RiAREJA4cB+5T1Ypco3oTHJJj23rQ1f2Mqj4PuBp4j6smMdYeHwPOA/qAQeDD1e1O6YhIO/AV4P2qmq52f1ZKjvHU9DVS1XlV7QN6gCtF5NJKHKfeBMcAEPN97wGOVakvZUNVj7n/jwN346jkap1hVw/t6aOPV7k/K0ZVh90fdgb4BDV2nVy9+VeAz6nqV93NNXudco2n1q+Rh6omge8Cr6YC16jeBMeDwG4ROUdEmoFrgXuq3KcVISJtrnEPEWkDfgF4dOm9aoJ7gLe5n98GfK2KfSkL3o/X5Q3U0HVyDa+fAg6o6t/4imryOuUbT41fo04RibifW4FXAgepwDWqK68qANe97m+BAHCnqv55lbu0IkTkXJxZBkAj8PlaG5OIfAG4Cif88zDwJ8C/AncBO4AjwK+oas0Ym/OM6SocFYgCh4F3ebrntY6IvBT4AbAfyLibb8GxC9TcdVpiPNdRu9foMhzjdwBnUnCXqv6piGymzNeo7gSHYRiGsTLqTVVlGIZhrBATHIZhGEZJmOAwDMMwSsIEh2EYhlESJjgMwzCMkjDBYRhVQETGfJ9f40Yu3VHNPhlGsTRWuwOGUc+IyCuAvwN+QVWPVLs/hlEMJjgMo0qIyM/ihLV4jao+U+3+GEax2AJAw6gCIjILjAJXqeoj1e6PYZSC2TgMozrMAj8G3lHtjhhGqZjgMIzqkMHJNvcCEbml2p0xjFIwG4dhVAlVnRCR1wI/EJFhVf1UtftkGMVggsMwqoiqnhKRVwPfF5ETqloTYcmN+saM44ZhGEZJmI3DMAzDKAkTHIZhGEZJmOAwDMMwSsIEh2EYhlESJjgMwzCMkjDBYRiGYZSECQ7DMAyjJP4v630D2x9DbloAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制KNN精度图\n",
    "# plt.figure(figsize=(8,6))\n",
    "plt.figure()\n",
    "plt.plot(k_range,k_accuracy)\n",
    "plt.title(\"the relationship between K and cross validate accuracy\")\n",
    "plt.xlabel(\"K\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T01:47:36.549925800Z",
     "start_time": "2023-09-08T01:47:35.962935600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最好的K值: [10, 11, 12]\n",
      "最好f1宏平均 0.9799832915622388\n"
     ]
    }
   ],
   "source": [
    "# 使用f1分数\n",
    "k_macro = []\n",
    "f1_macros = []\n",
    "for k in k_range:\n",
    "    knn = KNeighborsClassifier(n_neighbors=k)\n",
    "    f1_macro = cross_val_score(knn,X,y,scoring='f1_macro')\n",
    "    f1_macros.append(f1_macro.mean())\n",
    "\n",
    "# 找到最佳F1宏平均\n",
    "f1_macro_Max = max(f1_macros)\n",
    "# 找到所有f1_宏平均最大值对应的索引\n",
    "iIndexs = [idx for idx,x in enumerate(f1_macros) if x == f1_macro_Max]\n",
    "#m找到最好的K值\n",
    "best_K = [k_range[i] for i in iIndexs]\n",
    "print(\"最好的K值:\",best_K)\n",
    "print(\"最好f1宏平均\",f1_macro_Max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T01:49:48.588795Z",
     "start_time": "2023-09-08T01:49:48.165315800Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(k_range,f1_macros)\n",
    "plt.title(\"the relationship between f1_macro and k\")\n",
    "plt.xlabel(\"K\")\n",
    "plt.ylabel(\"f1_macro\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T02:24:20.182951400Z",
     "start_time": "2023-09-08T02:24:20.113957900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No.   指标名称 指标值\n",
      "--------------------------------------------------------------------------\n",
      "1     fit_time [0.00096202 0.00200582 0.00196362 0.00095654 0.00099826]\n",
      "2   score_time [0.00799513 0.00500822 0.003968   0.00503683 0.00300431]\n",
      "3    test_myF1 [0.97598344 0.97979798 1.         0.95138889 1.        ]\n",
      "4   train_myF1 [0.98091398 0.98005952 0.98103632 0.98146718 0.99084008]\n",
      "5   test_myRoc [0.996633   1.         1.         0.99479167 1.        ]\n",
      "6  train_myRoc [1.         0.99881165 0.99800638 0.99909701 0.99874309]\n"
     ]
    }
   ],
   "source": [
    "### 使用自定义评分器\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import ShuffleSplit\n",
    "from sklearn.metrics import make_scorer\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.model_selection import cross_validate\n",
    "# 导入数据集\n",
    "X,y = load_iris(return_X_y=True)\n",
    "\n",
    "# 构建分类评估器\n",
    "clf = svm.SVC(kernel='linear',C=1,probability=True,random_state=42)\n",
    "# 构建一个随机排列交叉验证器ShuffleSplit()对象\n",
    "cvSfl = ShuffleSplit(n_splits=5,test_size=0.3,random_state=0)\n",
    "# 使用make_scorer()构建评分器\n",
    "roc_Scorer = make_scorer(roc_auc_score,needs_proba=True,multi_class='ovo')\n",
    "# 可以同时使用多个度量指标\n",
    "myScore = {'myF1':'f1_macro','myRoc':roc_Scorer}\n",
    "# 交叉验证:返回结果为一个词典对象\n",
    "scores =cross_validate(clf,X,y,cv=cvSfl,return_train_score=True,scoring=myScore)\n",
    "# 输出每次划分对应的模型指标\n",
    "print(\"%s %6s %s\" % (\"No.\",'指标名称','指标值'))\n",
    "print(\"-\"*74)\n",
    "for index,scoreName in enumerate(scores):\n",
    "    print(\"%s %12s %s\" % (index+1,scoreName,scores[scoreName]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T02:47:52.057852500Z",
     "start_time": "2023-09-08T02:47:50.294450700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No   指标名称 指标值\n",
      "--------------------------------------------------------------------------\n",
      "1     fit_time [1.51993299e+00 1.00207329e-03 0.00000000e+00 0.00000000e+00\n",
      " 1.00040436e-03]\n",
      "2   score_time [0.01897073 0.         0.         0.         0.        ]\n",
      "3   test_score [-5.10941367 -5.0790876  -4.92527152 -4.90961548 -5.00902233]\n",
      "4  train_score [-4.94263237 -5.00688407 -5.10962758 -5.06011765 -5.05769361]\n",
      "--------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "### 基于自定义函数构造的评分器\n",
    "import numpy as np\n",
    "from sklearn.model_selection import ShuffleSplit\n",
    "from sklearn.metrics import make_scorer\n",
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.datasets import load_diabetes\n",
    "from sklearn.linear_model import LinearRegression\n",
    "# 一个自定义函数，其中kwargs表示其他额外的任何参数\n",
    "def my_custom_loss_func(y_true,y_pred,**kwargs):\n",
    "    diff = np.abs(y_true-y_pred).max()\n",
    "    return np.log1p(diff)\n",
    "\n",
    "# 导入数据\n",
    "X,y = load_diabetes(return_X_y=True)\n",
    "# my_score实际上是一个可以调用的函数\n",
    "my_score = make_scorer(my_custom_loss_func,greater_is_better=False)\n",
    "# 构建回归评估器\n",
    "regr = LinearRegression()\n",
    "# 构建一个随机排列交叉验证器ShuffleSplit()对象\n",
    "cvsl = ShuffleSplit(n_splits=5,test_size=0.3,random_state=0)\n",
    "# 交叉验证:返回一个词典对象\n",
    "scores = cross_validate(regr,X,y,cv=cvsl,return_train_score=True,scoring=my_score)\n",
    "# 输出每次划分对应的模型指标\n",
    "print(\"%s %6s %s\" % (\"No\",\"指标名称\",'指标值'))\n",
    "print(\"-\"*74)\n",
    "for index,scoreName in enumerate(scores):\n",
    "    print(\"%s %12s %s\" % (index+1,scoreName,scores[scoreName]))\n",
    "print(\"-\"*74)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T04:21:04.890315600Z",
     "start_time": "2023-09-08T04:21:04.866318Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原始数据集中目标变量分布情况:[-1  1],[100  50]\n",
      "--------------------------------------------------\n",
      "          支持向量分类(linear)评分: 0.631578947368421\n",
      "--------------------------------------------------\n",
      "哑分类评估器预测的目标变量分布情况 %s %s (array([-1]), array([150], dtype=int64))\n",
      "                  哑分类评估器评分: 0.5789473684210527\n",
      "--------------------------------------------------\n",
      "             支持向量分类(rbf)评分: 0.9473684210526315\n"
     ]
    }
   ],
   "source": [
    "# 哑分评估器和哑回归评估器\n",
    "import numpy as np\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "X,y = load_iris(return_X_y=True)\n",
    "# 转化二分类问题\n",
    "y[y!=1] = -1\n",
    "unique,count = np.unique(y,return_counts=True)\n",
    "print(\"原始数据集中目标变量分布情况:%s,%s\" %(unique,count))\n",
    "print(\"-\"*50)\n",
    "# 训练数据集与测试集的划分\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=0)\n",
    "# 线性支持向量分类评估器 这里kernel,C为超参数\n",
    "lnr_clf = SVC(kernel='linear',C=1).fit(X_train,y_train)\n",
    "print(\"%27s %s\" %(\"支持向量分类(linear)评分:\",lnr_clf.score(X_test,y_test)))\n",
    "print(\"-\"*50)\n",
    "# 哑分类评估器\n",
    "dm_clf = DummyClassifier(strategy='most_frequent',random_state=0)\n",
    "dm_clf.fit(X_train,y_train)\n",
    "# 查看哑分类评估器的返回值.这里总是返回出现频率最高的类别值\n",
    "y = dm_clf.predict(X)\n",
    "unique,count = np.unique(y,return_counts=True)\n",
    "print(\"哑分类评估器预测的目标变量分布情况 %s %s\",(unique,count))\n",
    "\n",
    "# 下面两条语句结果一样\n",
    "dm_score = dm_clf.score(X_test,y_test)\n",
    "print(\"%27s %s\" % (\"哑分类评估器评分:\",dm_score))\n",
    "print(\"-\"*50)\n",
    "# RBF支持向量分类评估器,这里kernel,C为超参数\n",
    "rbf_clf = SVC(kernel='rbf',C=1).fit(X_train,y_train)\n",
    "print(\"%27s %s\" % ('支持向量分类(rbf)评分:',rbf_clf.score(X_test,y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-08T05:10:51.204224Z",
     "start_time": "2023-09-08T05:10:47.041240600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "## 度量指标 (precision) 下的超参数调优 ##\n",
      "--------------------------------------------------\n",
      "基于训练数据集获得的最佳超参数组合如下:\n",
      "{'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "\n",
      "基于训练数据集的交叉验证 网格评分如下:\n",
      "0.986 (+/-0.016) for {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.959 (+/-0.028) for {'C': 1, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.988 (+/-0.017) for {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.982 (+/-0.026) for {'C': 10, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.988 (+/-0.017) for {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.983 (+/-0.026) for {'C': 100, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.988 (+/-0.017) for {'C': 1000, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.983 (+/-0.026) for {'C': 1000, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.974 (+/-0.012) for {'C': 1, 'kernel': 'linear'}\n",
      "0.974 (+/-0.012) for {'C': 10, 'kernel': 'linear'}\n",
      "0.974 (+/-0.012) for {'C': 100, 'kernel': 'linear'}\n",
      "0.974 (+/-0.012) for {'C': 1000, 'kernel': 'linear'}\n",
      "\n",
      "下面列出详细的分类报告\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        89\n",
      "           1       0.97      1.00      0.98        90\n",
      "           2       0.99      0.98      0.98        92\n",
      "           3       1.00      0.99      0.99        93\n",
      "           4       1.00      1.00      1.00        76\n",
      "           5       0.99      0.98      0.99       108\n",
      "           6       0.99      1.00      0.99        89\n",
      "           7       0.99      1.00      0.99        78\n",
      "           8       1.00      0.98      0.99        92\n",
      "           9       0.99      0.99      0.99        92\n",
      "\n",
      "    accuracy                           0.99       899\n",
      "   macro avg       0.99      0.99      0.99       899\n",
      "weighted avg       0.99      0.99      0.99       899\n",
      "\n",
      "## 度量指标 (recall) 下的超参数调优 ##\n",
      "--------------------------------------------------\n",
      "基于训练数据集获得的最佳超参数组合如下:\n",
      "{'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "\n",
      "基于训练数据集的交叉验证 网格评分如下:\n",
      "0.986 (+/-0.019) for {'C': 1, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.957 (+/-0.028) for {'C': 1, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.987 (+/-0.019) for {'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.981 (+/-0.028) for {'C': 10, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.987 (+/-0.019) for {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.982 (+/-0.026) for {'C': 100, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.987 (+/-0.019) for {'C': 1000, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "0.982 (+/-0.026) for {'C': 1000, 'gamma': 0.0001, 'kernel': 'rbf'}\n",
      "0.971 (+/-0.010) for {'C': 1, 'kernel': 'linear'}\n",
      "0.971 (+/-0.010) for {'C': 10, 'kernel': 'linear'}\n",
      "0.971 (+/-0.010) for {'C': 100, 'kernel': 'linear'}\n",
      "0.971 (+/-0.010) for {'C': 1000, 'kernel': 'linear'}\n",
      "\n",
      "下面列出详细的分类报告\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        89\n",
      "           1       0.97      1.00      0.98        90\n",
      "           2       0.99      0.98      0.98        92\n",
      "           3       1.00      0.99      0.99        93\n",
      "           4       1.00      1.00      1.00        76\n",
      "           5       0.99      0.98      0.99       108\n",
      "           6       0.99      1.00      0.99        89\n",
      "           7       0.99      1.00      0.99        78\n",
      "           8       1.00      0.98      0.99        92\n",
      "           9       0.99      0.99      0.99        92\n",
      "\n",
      "    accuracy                           0.99       899\n",
      "   macro avg       0.99      0.99      0.99       899\n",
      "weighted avg       0.99      0.99      0.99       899\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## 4.3.模型参数调优\n",
    "### 4.3.1.穷尽网格搜索\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# 导入手写数字图片数据集\n",
    "digits = datasets.load_digits()\n",
    "# 转化原始数据为(samples,feature)形式,便于使用分类模型\n",
    "n_samples = len(digits.images)\n",
    "X = digits.images.reshape((n_samples,-1))\n",
    "y = digits.target\n",
    "\n",
    "# 把数据集划分为训练集和测试数据集\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.5,random_state=0)\n",
    "\n",
    "# 设置超参数集合,以适应交叉验证\n",
    "tuned_parameters = [{'kernel':['rbf'],'gamma':[1e-3,1e-4],'C':[1,10,100,1000]},\n",
    "                    {'kernel':['linear'],'C':[1,10,100,1000]}\n",
    "                    ]\n",
    "scores = ['precision','recall']\n",
    "for score in scores:\n",
    "    print(\"## 度量指标 (%s) 下的超参数调优 ##\"%score)\n",
    "    print(\"--\"*25)\n",
    "    clf = GridSearchCV(SVC(),tuned_parameters,scoring='%s_macro' % score)\n",
    "    clf.fit(X_train,y_train) # 必须的一步\n",
    "    print(\"基于训练数据集获得的最佳超参数组合如下:\")\n",
    "    print(clf.best_params_)\n",
    "    print()\n",
    "    print(\"基于训练数据集的交叉验证 网格评分如下:\")\n",
    "    means = clf.cv_results_['mean_test_score']\n",
    "    stds = clf.cv_results_['std_test_score']\n",
    "    for mean,std,params in zip(means,stds,clf.cv_results_['params']):\n",
    "        print('%0.3f (+/-%0.03f) for %r'% (mean,std*2,params))\n",
    "    print()\n",
    "    print(\"下面列出详细的分类报告\")\n",
    "    y_true,y_pred=y_test,clf.predict(X_test)\n",
    "    print(classification_report(y_true,y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3.2.随机超参数搜索"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-10T02:07:25.727276800Z",
     "start_time": "2023-09-10T02:07:25.577284400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "随机搜索中的最优参数组合:\n",
      "{'kernel': 'linear', 'gamma': 0.001, 'C': 10}\n",
      "最佳组合在测试集上的精度: 0.958041958041958\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 准备数据\n",
    "cancer = load_breast_cancer()\n",
    "X_train,X_test,y_train,y_test = train_test_split(cancer.data,cancer.target,random_state=0)\n",
    "scaler = MinMaxScaler()\n",
    "scaler.fit(X_train)\n",
    "X_train_scaled = scaler.transform(X_train)\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "\n",
    "# 构建模型\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "\n",
    "params_grid = {'kernel':['rbf','linear'],'gamma':[0.001,0.01,0.1,1,10],'C':[0.001,0.01,0.1,1,10]}\n",
    "RandCV = RandomizedSearchCV(SVC(),param_distributions=params_grid,random_state=0,n_jobs=-1)\n",
    "RandCV.fit(X_train_scaled,y_train)\n",
    "print(\"随机搜索中的最优参数组合:\")\n",
    "print(RandCV.best_params_)\n",
    "print(\"最佳组合在测试集上的精度:\",RandCV.score(X_test_scaled,y_test))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-10T02:10:08.537118500Z",
     "start_time": "2023-09-10T02:10:08.503118500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6291108071135431 0.00529565508593605 {'kernel': 'rbf', 'gamma': 10, 'C': 0.1}\n",
      "0.793406292749658 0.02198991240445245 {'kernel': 'linear', 'gamma': 0.001, 'C': 0.01}\n",
      "0.6267578659370725 0.004592533025085026 {'kernel': 'rbf', 'gamma': 0.001, 'C': 0.01}\n",
      "0.9812311901504789 0.017593509352981544 {'kernel': 'linear', 'gamma': 0.001, 'C': 10}\n",
      "0.6267578659370725 0.004592533025085026 {'kernel': 'rbf', 'gamma': 0.01, 'C': 0.001}\n",
      "0.9508071135430918 0.02473384743154829 {'kernel': 'linear', 'gamma': 1, 'C': 0.1}\n",
      "0.9342270861833105 0.01772576009431347 {'kernel': 'rbf', 'gamma': 10, 'C': 1}\n",
      "0.9765253077975377 0.012888054248795404 {'kernel': 'linear', 'gamma': 0.001, 'C': 1}\n",
      "0.6267578659370725 0.004592533025085026 {'kernel': 'rbf', 'gamma': 0.01, 'C': 0.1}\n",
      "0.6267578659370725 0.004592533025085026 {'kernel': 'rbf', 'gamma': 0.1, 'C': 0.001}\n"
     ]
    }
   ],
   "source": [
    "# 获取所有参数组合\n",
    "means = RandCV.cv_results_['mean_test_score']\n",
    "stds = RandCV.cv_results_['std_test_score']\n",
    "for mean,std,params in zip(means,stds,RandCV.cv_results_['params']):\n",
    "    print(mean,std,params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-10T02:31:18.866742900Z",
     "start_time": "2023-09-10T02:31:18.544993100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9666080843585237\n"
     ]
    }
   ],
   "source": [
    "# 袋外数据\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "rand_classifier = RandomForestClassifier(oob_score=True)\n",
    "rand_classifier.fit(cancer.data,cancer.target)\n",
    "print(rand_classifier.oob_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 验证曲线\n",
    "### 4.4.1 交叉验证曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-10T03:51:55.792744Z",
     "start_time": "2023-09-10T03:51:33.828298100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.00000000e-06 1.77827941e-05 3.16227766e-04 5.62341325e-03\n",
      " 1.00000000e-01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n",
      "Font 'default' does not have a glyph for '-' [U+2212], substituting with a dummy symbol.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import  numpy as np\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.datasets import load_digits\n",
    "from sklearn.model_selection import validation_curve\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 导入系统自带手写数据集\n",
    "X,y = load_digits(return_X_y=True)\n",
    "# 构造validation_curve曲线\n",
    "param_range = np.logspace(-6,-1,5) # 生成对数等比数列\n",
    "print(param_range)\n",
    "# 交叉验证参数cv默认为5\n",
    "train_scores,test_scores = validation_curve(SVC(),X,y,param_name='gamma',param_range=param_range,scoring='accuracy',n_jobs=1)\n",
    "\n",
    "train_scores_mean = np.mean(train_scores,axis=1)\n",
    "train_scores_std = np.std(train_scores,axis=1)\n",
    "test_scores_mean= np.mean(test_scores,axis=1)\n",
    "test_scores_std = np.std(test_scores,axis=1)\n",
    "# 绘制图形\n",
    "fig = plt.figure(figsize=(10,6))\n",
    "# 支持中文\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签\n",
    "plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号\n",
    "\n",
    "plt.title(\"模型Svm交叉验证曲线\")\n",
    "plt.xlabel('gamma系数')\n",
    "plt.ylabel(\"评分\")\n",
    "plt.ylim(0.0,1.1)\n",
    "plt.semilogx(param_range,train_scores_mean,label='训练评分',color='darkorange',lw=2)\n",
    "plt.fill_between(param_range,train_scores_mean-train_scores_std,\n",
    "                 train_scores_mean+train_scores_std,alpha=0.2,color='darkorange')\n",
    "plt.semilogx(param_range,test_scores_mean,label='交叉验证评分',color='navy',lw=2)\n",
    "plt.fill_between(param_range,test_scores_mean-test_scores_std,test_scores_std+test_scores_mean,\n",
    "                 alpha=0.2,color='navy')\n",
    "# 图例\n",
    "plt.legend(loc='best',fancybox=True,shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
